import javax.swing.*;
import java.util.ArrayList;
import java.util.Scanner;

/**
 * Created whit IntelliJ IDEA.
 * Description：
 * User：ZHONGCHEN
 * Date:2022-03-23
 * Time:21:09
 */
public class TestDemo {
    /**
     * 661. 图片平滑器
     */
    int[][] ans;
    int n, m;
    int[][] step = {{1, 1}, {1, 0}, {1, -1}, {0, 1}, {0, -1}, {-1, 0}, {-1, 1}, {-1, -1}};
    //朴素遍历
    public int[][] imageSmoother(int[][] img) {
        n = img.length;
        m = img[0].length;
        ans = new int[n][m];
        //遍历每个位置
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                avg(ans, img, i, j);
            }
        }
        return ans;
    }

    private void avg(int[][] ans, int[][] img, int row, int col) {
        int sum = img[row][col];
        //无论如何都算上自己本身 所有count初始值为1
        int count = 1;
        int r = row;
        int c = col;
        //向周围8个位置走一遍
        for (int[] a : step) {
            row += a[0];
            col += a[1];
            //判断走的位置是否合法;不合法就重置row col并跳过
            if (row < 0 || col < 0 || row >= n || col >= m) {
                //row col 不合规格则重置
                row = r;
                col = c;
                continue;
            }
            count++;
            sum += img[row][col];
            //相加后也要把row col重置
            row = r;
            col = c;
        }
        //把答案放在一个新的二维数组中
        ans[r][c] = sum / count;
    }

    public static void main(String[] args) {
       int[][] num = {{1,1,1},{1,0,1},{1,1,1}};
       imageSmoother1(num);
        System.out.println(1);
    }
    //前缀和
    //对于某个 ans[i][j]ans[i][j] 而言，我们可以直接计算出其所在 item 的左上角 (a, b) = (i - 1, j - 1)(a,b)=(i−1,j−1)
    // 以及其右下角 (c, d) = (i + 1, j + 1)(c,d)=(i+1,j+1)，同时为了防止超出原矩阵，
    // 我们需要将 (a, b)(a,b) 与 (c, d)(c,d) 对边界分别取 max 和 min。
    //当有了合法的 (a, b)(a,b) 和 (c, d)(c,d) 后，我们可以直接计算出 item 的单元格数量（所包含的行列乘积）
    // 及 item 的单元格之和（前缀和查询），从而算得 ans[i][j]ans[i][j]。

    public static int[][] imageSmoother1(int[][] img) {
        int m = img.length, n = img[0].length;
        int[][] sum = new int[m + 10][n + 10];
        //求img的前缀和
        for (int i = 1; i <= m; i++) {
            for (int j = 1; j <= n; j++) {
                sum[i][j] = sum[i - 1][j] + sum[i][j - 1] - sum[i - 1][j - 1] + img[i - 1][j - 1];
            }
        }
        int[][] ans = new int[m][n];
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                int a = Math.max(0, i - 1), b = Math.max(0, j - 1);
                int c = Math.min(m - 1, i + 1), d = Math.min(n - 1, j + 1);
                //求出该位置需要计算多个数字
                int cnt = (c - a + 1) * (d - b + 1);
                //依然是前缀和,把多加的减去;把多减的加回来
                int tot = sum[c + 1][d + 1] - sum[a][d + 1] - sum[c + 1][b] + sum[a][b];
                ans[i][j] = tot / cnt;
            }
        }
        return ans;
    }


    //猴子分桃

    /**
     * 老猴子辛苦了一辈子，给那群小猴子们留下了一笔巨大的财富——一大堆桃子。老猴子决定把这些桃子分给小猴子。
     * 第一个猴子来了，它把桃子分成五堆，五堆一样多，但还多出一个。它把剩下的一个留给老猴子，自己拿走其中的一堆。
     * 第二个猴子来了，它把桃子分成五堆，五堆一样多，但又多出一个。它把多出的一个留给老猴子，自己拿走其中的一堆。
     * 后来的小猴子都如此照办(每只都把桃子平均分5堆,且多一个,那一个给老猴子)。(若剩下的桃子不能平均分成五堆且
     * 剩下一个桃子;则把剩下的桃子全部留给老猴子)最后剩下的桃子全部留给老猴子。
     * 这里有n只小猴子，请你写个程序计算一下在开始时至少有多少个桃子，以及最后老猴子最少能得到几个桃子。
     * <p>
     * 思路：因为每次分5堆都会多出来1个，所以我们借给猴子们4个，以致每次都可以刚好分成5堆
     * 并且，每次给老猴子的桃子都不在我们借出的那4个中，这样最后减掉4就可以得到结果。
     * 假设最初由x个桃子，我们借给猴子4个，则此时有x+4个，
     * 第一个猴子得到（x+4）/5，剩余（x+4）*（4/5）个
     * 第二个猴子分完后剩余（x+4）*(4/5)^2个
     * 第三个猴子分完后剩余（x+4）*(4/5)^3个
     * 依次类推，最后一个猴子分完后剩余（x+4）*（4/5）^n
     * 要满足最后剩余的为整数，并且x最小，则当 x+4=5^n时，满足要求
     * 此时，x=5^n-4;
     * 老猴子得到的数量为：old = （x+4）*（4/5）^n + n - 4
     * = 4^n + n - 4
     * 最后加n是因为不是剩余多出来的一个，而是小猴子给的，比如桃子是有6个，小猴子本身只能拿一个，我们借给4个，小猴就能拿两个，那多出来的哪一个给老猴子，和之前6个整除五余1一个道理
     * 最后老猴子减4是还给我们借给它们的那4个
     */
    public static void main1(String[] args) {
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()) {
            int n = scanner.nextInt();
            if (n == 0) {
                break;
            }
            long peach = (long) Math.pow(5, n) - 4;
            long oldMonkey = (long) Math.pow(4, n) + n - 4;
            System.out.println(peach + " " + oldMonkey);
        }
    }
}
